1. Technical Field
The present invention relates generally to dynamic programming environments, and more particularly to a dynamic programming platform that supports bulk data operators designed to operate in a shared memory space in a multithreaded environment.
2. Related Art
In data-centric software development, it is typical to identify and lay out blocks of raw data (typically large volumes of floating point or integer data) that developers desire to access both (a) en masse (rather than at the element level) and (b) from multiple threads with as little synchronization overhead as possible.
As to (a), accessing data en masse rather than at the element level generally makes code more compact and maintainable, but also increases overall performance significantly because loops that had to previously make passes though data elements instead appear as primitive and compact operations within the language execute in efficient, native, “tight” loops with minimal overhead.
Regarding (b), developers also seek to access shared blocks of data from multiple worker threads in organized ways specifically designed to remove the need for thread synchronization. When worker threads can easily access and operate on sub-sections of the data in a parallel fashion, then the host platform's hardware can be fully loaded with negligible synchronization overhead (rather than, e.g. confining computation to a single thread or be impaired by costly use of OS-level heavyweight synchronization). For example, it's typical and effective for large buffers to be shared between worker threads where, by design, each worker thread only accesses predetermined sub-ranges of the input and output data buffers. This allows multiple worker threads to run simultaneously without synchronization overhead since their working range of data access has been designed so that each worker thread can read and write concurrently without any possibility of data loss or corruption due to race conditions.
These “developer knows best” design patterns are attractive because they require no synchronization overhead and crafted to be inherently safe and uncomplicated. However, if a dynamic language runtime imposes a synchronization specification for all data access, then even a multi-threaded design pattern without any need for synchronization will perform poorly as each data element access incurs the synchronization overhead imposed by the runtime environment.
There is a clear demand for software developers to access large blocks of raw data (a) en masse to reduce total overhead and (b) in sub-sections that multi-threaded worker design patterns can leverage to remove any need for data access synchronization. That is, as dynamic languages evolve, it's clear there's a contemporary demand for built-in, high performance, “element-wise” computation on large blocks of raw data that can be accessed outside the language's normal requirements of object safety and synchronization.
There are a number of third-party add-ons that deliver data computation tools that address some of these aspects (generally associated with efficient and parallelizable bulk data computation), but by nature of being third-party add-ons, they impose restrictions on the host platform and therefore the portability of code that uses these add-ons. Because they also add-on to the language environment, they require developers to invest time setting up the add-on and learning the details and nuances of the particular add-on. Host platform restrictions or a new learning curve may not impede some developers, but they do restrict a language's broader appeal since every developer interested in clean and efficient bulk data computation is immediately burdened with having to reinvent the computational wheel (or at least shop around for one and deal with installing it).